// @/utils/dictUtil.ts
import { getDictDateByDictType } from "@/api/systemManagement/sysDictData/sysDictData";
import { getCurrencyList } from "@/api/pmManagement/pmCurrency/pmCurrency";
import { getTransChannelList } from "@/api/pmManagement/pmTransChannel/pmTransChannel";
import { getGroupList } from "@/api/pmManagement/pmChooseGroup/pmChooseGroup";//选择组类型接口
import { getChannelList } from "@/api/pmManagement/pmTransChannel/pmTransChannel";//渠道类型接口
import { getPriorityList } from "@/api/pmManagement/pmPriority/pmPriority";//优先级接口
import { getProductList } from "@/api/pmManagement/pmMonitorProduct/pmMonitorProduct";
import { getElementTypeList } from "@/api/pmManagement/PmElementType/PmElementType";
import { message } from "ant-design-vue";
import { Ref } from "vue";

// 定义产品类型接口
export interface ProductItem {
  productCode: string; // 产品编号
  productName: string; // 产品名称
}
// 产品编号变化时，自动映射名称
export const handleProductChange = (
  productCode: string,
  productList: ProductItem[],
  formState: { productName: string }
) => {
  if (!productCode) {
    formState.productName = '';  // 清空选择时，名称也清空
    return;
  }

  // 根据选中的编号查找对应的组信息
  const selectedGroup = productList.find(
    product => product.productCode === productCode
  );

  // 映射名称（找不到时显示空）
  formState.productName = selectedGroup?.productName || '';
};
// 获取产品列表数据
export const fetchProductList = async (
  productList: Ref<ProductItem[]>,
  productLoading: Ref<boolean>) => {
  productLoading.value = true;
  try {
    getProductList().then(
      (res: {
        code: number | string;
        msg: string;
        total: number;
        rows: any;
      }) => {
        const { code, msg, total: count, rows } = res;
        console.log("产品接口编码：" + code);
        if (code === 200) {
          productList.value = rows;
        } else {
          message.error("获取产品列表失败：" + res.msg);
          productList.value = [];
        }
      }
    )
  } catch (error) {
    message.error("获取产品列表出错");
    productList.value = [];
  } finally {
    productLoading.value = false;
  }
};
// 产品下拉框模糊匹配逻辑
export const filterProduct = (inputValue: string, option: any, productList: ProductItem[]) => {
  // inputValue：用户输入的关键词
  // option.value：当前选项
  if (!inputValue) return true; // 空输入时显示所有选项

  // 根据渠道找到对应的渠道对象
  const product = productList.find(
    item => item.productCode === option.value
  );
  if (!product) return false;

  // 模糊匹配渠道名称和Id（忽略大小写）
  return product.productCode.toLowerCase().includes(inputValue.toLowerCase()) ||
    (product.productName && product.productName.toLowerCase().includes(inputValue.toLowerCase()));
};
// 定义渠道类型接口
export interface ChannelItem {
  transChannelCode: string; // 渠道编号
  transChannelName: string; // 渠道名称
}
// 获取渠道列表数据
export const fetchChannelList = async (
  channelList: Ref<ChannelItem[]>,
  channelLoading: Ref<boolean>) => {
  channelLoading.value = true;
  try {
    getChannelList().then(
      (res: {
        code: number | string;
        msg: string;
        total: number;
        rows: any;
      }) => {
        const { code, msg, total: count, rows } = res;
        console.log("渠道接口编码：" + code);
        if (code === 200) {
          channelList.value = rows;
        } else {
          message.error("获取渠道列表失败：" + res.msg);
          channelList.value = [];
        }
      }
    )
  } catch (error) {
    message.error("获取渠道列表出错");
    channelList.value = [];
  } finally {
    channelLoading.value = false;
  }
};
// 渠道编号变化时，自动映射名称
export const handleChannelChange = (
  transChannelCode: string,
  channelList: ChannelItem[],
  formState: { channelName: string }
) => {
  if (!transChannelCode) {
    formState.channelName = '';  // 清空选择时，名称也清空
    return;
  }

  // 根据选中的编号查找对应的组信息
  const selectedGroup = channelList.find(
    channel => channel.transChannelCode === transChannelCode
  );

  // 映射名称（找不到时显示空）
  formState.channelName = selectedGroup?.transChannelName || '';
};
export const filterChannelByName = (inputValue: string, option: any) => {
  if (!inputValue) return true;
  const channelName = option.value || '';
  return channelName.toLowerCase().includes(inputValue.toLowerCase());
};
// 渠道下拉框模糊匹配逻辑
export const filterChannel = (inputValue: string, option: any, channelList: ChannelItem[]) => {
  // inputValue：用户输入的关键词
  // option.value：当前选项
  if (!inputValue) return true; // 空输入时显示所有选项

  // 根据产品找到对应的产品对象
  const channel = channelList.find(
    item => item.transChannelCode === option.value
  );
  if (!channel) return false;

  // 模糊匹配产品名称和Id（忽略大小写）
  return channel.transChannelCode.toLowerCase().includes(inputValue.toLowerCase()) ||
    (channel.transChannelName && channel.transChannelName.toLowerCase().includes(inputValue.toLowerCase()));
};

// 定义选择组类型接口
export interface GroupItem {
  chooseGroupId: string; // 选择组编号
  chooseGroupName: string; // 选择组名称
}
// 获取选择组列表数据
export const fetchGroupList = async (
  groupList: Ref<GroupItem[]>,
  groupLoading: Ref<boolean>
) => {
  groupLoading.value = true;
  try {
    getGroupList().then(
      (res: {
        code: number | string;
        msg: string;
        total: number;
        rows: any;
      }) => {
        const { code, msg, total: count, rows } = res;
        console.log("选择组接口编码：" + code);
        if (code === 200) {
          groupList.value = rows;
        } else {
          message.error("获取选择组列表失败：" + res.msg);
          groupList.value = [];
        }
      }
    )
  } catch (error) {
    message.error("获取选择组列表出错");
    groupList.value = [];
  } finally {
    groupLoading.value = false;
  }
};
// 选择组下拉框模糊匹配逻辑
export const filterGroup = (inputValue: string, option: any, groupList: GroupItem[]) => {
  // inputValue：用户输入的关键词
  // option.value：当前选项
  if (!inputValue) return true; // 空输入时显示所有选项

  // 根据选择组找到对应的选择组对象
  const group = groupList.find(
    item => item.chooseGroupId === option.value
  );
  if (!group) return false;

  // 模糊匹配选择组名称（忽略大小写）
  return group.chooseGroupName.toLowerCase().includes(inputValue.toLowerCase());
};
// 弹窗选择组变更：映射名称
export const handleModalGroupChange = (
  chooseGroupId: string,
  groupList: GroupItem[],
  formState: { chooseGroupName: string }
) => {
  if (!chooseGroupId) {
    formState.chooseGroupName = '';
    return;
  }
  const selectedGroup = groupList.find(group => group.chooseGroupId === chooseGroupId);
  formState.chooseGroupName = selectedGroup?.chooseGroupName || '未找到对应选择组';
};
// 字典项接口（通用，与后端返回结构对齐）
export interface DictItem {
  dictLabel: string; // 字典显示值（如“是”“否”）
  dictValue: string; // 字典实际值（如“Y”“N”）
  dictType?: string; // 字典类型（可选，用于区分不同字典）
  [key: string]: any; // 兼容其他字段
}

/**
 * 公共方法：获取字典数据
 * @param dictType 字典类型（如“is_default”“clearing_mode”“is_summer_time”）
 * @param dictList 存储字典数据的响应式变量（ref数组）
 * @param loading 控制加载状态的响应式变量（ref布尔值）
 */
export const fetchDictData = async (
  dictType: string,
  dictList: Ref<DictItem[]>,
  loading: Ref<boolean>
) => {
  loading.value = true; // 开始加载
  try {
      getDictDateByDictType(dictType).then(
        (res: {
          code: number | string;
          msg: string;
          total: number;
          data: any;
        }) => {
          const { code, msg, total: count, data } = res;
          console.log("字典接口编码：" + code);
          if (code === 200) {
            dictList.value = data;
          } else {
            message.error("获取字典列表失败：" + res.msg);
            dictList.value = [];        
          }
        }
      )    
  } catch (error) {
    message.error(`获取【${dictType}】字典出错`);
    dictList.value = []; // 异常：清空数据
  } finally {
    loading.value = false; // 结束加载（无论成功/失败）
  }
};

// 2. 币种项接口（与后端币种表结构对齐）
export interface CurrencyItem {
  currencyCode: string; // 币种编码（如 CNY、USD）
  currencyName: string; // 币种名称（如 人民币、美元）
  [key: string]: any; // 兼容其他字段
}
/**
 * 公共方法：获取币种列表（币种表专用）
 * @param currencyList 存储币种数据的响应式变量（ref数组）
 * @param loading 控制加载状态的响应式变量（ref布尔值）
 */
export const fetchCurrencyList = async (
  currencyList: Ref<CurrencyItem[]>,
  loading: Ref<boolean>
) => {
  loading.value = true;
  try {
    const res = await getCurrencyList();
    const { code, msg, rows = [] } = res; // 假设后端返回 rows 字段
    if (code === 200) {
      currencyList.value = rows;
    } else {
      message.error(`获取币种列表失败：${msg}`);
      currencyList.value = [];
    }
  } catch (error) {
    message.error(`获取币种列表出错：${error instanceof Error ? error.message : '未知错误'}`);
    currencyList.value = [];
  } finally {
    loading.value = false;
  }
};

// 新增：定义币种匹配字段类型（支持编码或名称）
type CurrencyMatchField = 'currencyCode' | 'currencyName';
/**
 * 公共方法：币种下拉框模糊匹配（支持动态指定匹配字段）
 * @param inputValue 用户输入的搜索关键词
 * @param option 下拉框当前选项
 * @param currencyList 币种列表数据
 * @param matchField 匹配字段（默认用 currencyCode，可选 currencyName）
 * @returns 是否匹配成功
 */
export const filterCurrency = (
  inputValue: string,
  option: any,
  currencyList: CurrencyItem[],
  matchField: CurrencyMatchField = 'currencyCode' // 默认按编码匹配
) => {
  if (!inputValue) return true; // 空输入显示所有选项

  // 根据动态字段（currencyCode 或 currencyName）找到对应的币种对象
  const currency = currencyList.find(
    item => item[matchField] === option.value
  );
  if (!currency) return false;

  // 模糊匹配币种名称（忽略大小写）
  return currency.currencyName.toLowerCase().includes(inputValue.toLowerCase());
};
/**
 * 根据币种编码获取币种名称
 * @param currencyCode 币种编码（如 CNY、USD）
 * @param currencyList 币种列表数据
 * @returns 对应的币种名称（如 人民币），未找到则返回空字符串
 */
export const getCurrencyNameByCode = (
  currencyCode: string,
  currencyList: CurrencyItem[]
): string => {
  if (!currencyCode) return ""; // 编码为空时直接返回空
  // 查找匹配的币种
  const matchedCurrency = currencyList.find(
    item => item.currencyCode === currencyCode
  );
  return matchedCurrency ? matchedCurrency.currencyName : "";
};

/**
 * 处理币种选择变化，同步币种名称到表单
 * @param code 选中的币种编码
 * @param currencyList 币种列表数据
 * @param formState 表单对象（包含 currencyName 字段）
 */
export const handleCurrencyChange = (
  code: string,
  currencyList: CurrencyItem[],
  formState: { currencyName: string }
) => {
  // 调用上面的工具方法获取名称
  formState.currencyName = getCurrencyNameByCode(code, currencyList);
};

/**
 * 通用字典值转换：根据字典类型和原始值，返回目标值（如中文→编码/Y/N）
 * @param dictType 字典类型（如 'is_default'、'clearing_mode'）
 * @param rawValue 原始值（如 '是'、'否' 或后端返回的中文）
 * @param dictList 该字典类型对应的字典列表（用于匹配映射关系）
 * @returns 转换后的目标值（如 'Y'、'N' 或字典中的 dictValue）
 */
export const convertDictValue = (
  dictType: string,
  rawValue: string,
  dictList: DictItem[]
): string => {
  if (!rawValue || !dictList.length) return '';

  // 查找字典中与原始值匹配的项（优先匹配 dictLabel，即中文）
  const matchedItem = dictList.find(
    item => item.dictLabel === rawValue || item.dictValue === rawValue
  );

  // 返回对应的 dictValue（编码），未找到则返回原始值
  return matchedItem ? matchedItem.dictValue : rawValue;
};

// 3. 渠道平台项接口（与后端渠道平台表结构对齐）
export interface TransChannelItem {
  transChannelCode: string; // 渠道编码（如 ALIPAY、WECHAT）
  transChannelName: string; // 渠道名称（如 支付宝、微信支付）
  [key: string]: any; // 兼容其他字段
}

/**
 * 公共方法：获取渠道平台列表（渠道平台表专用）
 * @param transChannelList 存储渠道平台数据的响应式变量（ref数组）
 * @param loading 控制加载状态的响应式变量（ref布尔值）
 */
export const fetchTransChannelList = async (
  transChannelList: Ref<TransChannelItem[]>,
  loading: Ref<boolean>
) => {
  loading.value = true;
  try {
    const res = await getTransChannelList();
    const { code, msg, rows = [] } = res; // 假设后端返回 rows 字段存储列表数据
    if (code === 200) {
      transChannelList.value = rows;
    } else {
      message.error(`获取渠道平台列表失败：${msg}`);
      transChannelList.value = [];
    }
  } catch (error) {
    message.error(`获取渠道平台列表出错：${error instanceof Error ? error.message : '未知错误'}`);
    transChannelList.value = [];
  } finally {
    loading.value = false;
  }
};

/**
 * 根据渠道编码获取渠道名称
 * @param channelCode 渠道编码（如 ALIPAY、WECHAT）
 * @param transChannelList 渠道平台列表数据
 * @returns 对应的渠道名称（如 支付宝），未找到则返回空字符串
 */
export const getChannelNameByCode = (
  channelCode: string,
  transChannelList: TransChannelItem[]
): string => {
  if (!channelCode) return ""; // 编码为空时直接返回空
  // 查找匹配的渠道
  const matchedChannel = transChannelList.find(
    item => item.transChannelCode  === channelCode
  );
  return matchedChannel ? matchedChannel.transChannelName  : "";
};

/**
 * 处理渠道平台选择变化，同步渠道名称到表单
 * @param code 选中的渠道编码
 * @param transChannelList 渠道平台列表数据
 * @param formState 表单对象（包含 channelName 字段）
 */
export const handleTransChannelChange = (
  code: string,
  transChannelList: TransChannelItem[],
  formState: { channelName: string }
) => {
  // 调用工具方法获取名称
  formState.channelName = getChannelNameByCode(code, transChannelList);
};


// 4. 要素类型项接口（与后端要素类型表结构对齐，不含elementTypeId）
export interface ElementTypeItem {
  elementTypeEnName: string; // 要素类型英文名称（作为唯一标识）
  elementTypeCnName: string; // 要素类型中文名称
  [key: string]: any; // 兼容其他字段（如渠道ID、备注等）
}

/**
 * 公共方法：获取要素类型列表（要素类型表专用）
 * @param elementTypeList 存储要素类型数据的响应式变量（ref数组）
 * @param loading 控制加载状态的响应式变量（ref布尔值）
 */
export const fetchElementTypeList = async (
  elementTypeList: Ref<ElementTypeItem[]>,
  loading: Ref<boolean>
) => {
  loading.value = true;
  try {
    const res = await getElementTypeList();
    const { code, msg, rows = [] } = res; // 假设后端返回 rows 字段存储列表数据
    if (code === 200) {
      elementTypeList.value = rows;
      console.log("要素类型列表加载成功，共", rows.length, "条数据");
    } else {
      message.error(`获取要素类型列表失败：${msg}`);
      elementTypeList.value = [];
    }
  } catch (error) {
    message.error(`获取要素类型列表出错：${error instanceof Error ? error.message : '未知错误'}`);
    elementTypeList.value = [];
  } finally {
    loading.value = false;
  }
};

/**
 * 根据要素类型英文名称获取中文名称
 * @param elementTypeEnName 要素类型英文名称（唯一标识）
 * @param elementTypeList 要素类型列表数据
 * @returns 对应的要素类型中文名称，未找到则返回空字符串
 */
// export const getElementTypeCnNameByEn = (
//   elementTypeEnName: string,
//   elementTypeList: ElementTypeItem[]
// ): string => {
//   console.log("elementTypeEnName", elementTypeEnName)
//   if (!elementTypeEnName) return "";
//   const matchedType = elementTypeList.find(
//     item => item.elementTypeEnName === elementTypeEnName
//   );
//   return matchedType ? matchedType.elementTypeCnName : "";
// };

/**
 * 处理要素类型选择变化，同步中文名称到表单
 * @param enName 选中的要素类型英文名称（唯一标识）
 * @param elementTypeList 要素类型列表数据
 * @param formState 表单对象（包含 elementTypeCnName 字段）
 */
export const handleElementTypeChange = (
  enName: string,
  elementTypeList: ElementTypeItem[],
  formState: { elementType: string }
) => {
  formState.elementType = enName;
};

// 5. 优先级接口（与后端优先级表结构对齐）
export interface PriorityItem {
  priorityNo: string; // 优先级编号
  priorityName: string; // 优先级名称
}

/**
 * 公共方法：获取优先级列表（优先级表专用）
 * @param priorityList 存储优先级数据的响应式变量（ref数组）
 * @param loading 控制加载状态的响应式变量（ref布尔值）
 */
export const fetchPriorityList = async (
  priorityList: Ref<PriorityItem[]>,
  loading: Ref<boolean>
) => {
  loading.value = true;
  try {
    const res = await getPriorityList();
    const { code, msg, rows = [] } = res; // 假设后端返回 rows 字段存储列表数据
    if (code === 200) {
      priorityList.value = rows;
    } else {
      message.error(`获取优先级列表失败：${msg}`);
      priorityList.value = [];
    }
  } catch (error) {
    message.error(`获取优先级列表出错：${error instanceof Error ? error.message : '未知错误'}`);
    priorityList.value = [];
  } finally {
    loading.value = false;
  }
};

/**
 * 根据渠道编码获取渠道名称
 * @param priorityNo 优先级编号 
 * @param priorityList 优先级列表数据
 * @returns 对应的优先级名称，未找到则返回空字符串
 */
export const getPriorityNameByNo = (
  priorityNo: string,
  priorityList: PriorityItem[]
): string => {
  if (!priorityNo) return ""; // 编码为空时直接返回空
  // 查找匹配的优先级
  const matchedPriority = priorityList.find(
    item => item.priorityNo  === priorityNo
  );
  return matchedPriority ? matchedPriority.priorityName  : "";
};

/**
 * 处理优先级选择变化，同步优先级名称到表单
 * @param priorityNo 选中的优先级编码
 * @param priorityList 优先级列表数据
 * @param formState 表单对象（包含 priorityName 字段）
 */
export const handlePriorityChange = (
  priorityNo: string,
  priorityList: PriorityItem[],
  formState: { priorityName: string }
) => {
  // 调用工具方法获取名称
  formState.priorityName = getPriorityNameByNo(priorityNo, priorityList);
};
// 产品下拉框模糊匹配逻辑
export const filterPriority = (inputValue: string, option: any, priorityList: PriorityItem[]) => {
  // inputValue：用户输入的关键词
  // option.value：当前选项
  if (!inputValue) return true; // 空输入时显示所有选项

  // 根据产品找到对应的产品对象
  const priority = priorityList.find(
    item => item.priorityNo === option.value
  );
  if (!priority) return false;

  // 模糊匹配产品名称和Id（忽略大小写）
  return priority.priorityNo.toLowerCase().includes(inputValue.toLowerCase()) ||
    (priority.priorityName && priority.priorityName.toLowerCase().includes(inputValue.toLowerCase()));
};